package cur.nature.component.redis.redis;//package cur.base.cache.redis;
//
//import org.slf4j.Logger;
//import org.slf4j.LoggerFactory;
//import org.springframework.beans.factory.annotation.Qualifier;
//import org.springframework.data.redis.core.ReactiveRedisTemplate;
//import org.springframework.stereotype.Component;
//import reactor.core.publisher.Flux;
//import reactor.core.publisher.Mono;
//import java.time.Duration;
//import java.util.List;
//import java.util.Map;
//import java.util.stream.Collectors;
//
//
//@Component
////@DependsOn("redisTemplate")
//public class  RedisReactiveUtil {
//    private Logger log = LoggerFactory.getLogger(getClass());
//    private static ReactiveRedisTemplate redisTemplate;
//
//    private RedisReactiveUtil(@Qualifier("reactiveRedisTemplate") ReactiveRedisTemplate reactiveRedisTemplate){
//        redisTemplate = reactiveRedisTemplate;
//    }
//
//    /**
//     * 指定缓存失效时间
//     * @param key 键
//     * @param time 时间(秒)
//     * @return
//     */
//    public static boolean expire(String key,long time){
//        try {
//            if(time>0){
//                redisTemplate.expire(key, Duration.ofSeconds(time)).block();
//            }
//            return true;
//        } catch (Exception e) {
//            e.printStackTrace();
//            return false;
//        }
//    }
//
//    /**
//     * 根据key 获取过期时间
//     * @param key 键 不能为null
//     * @return 时间(秒) 返回0代表为永久有效
//     */
//    public static long getExpire(String key){
//        Mono<Duration> duration = redisTemplate.getExpire(key);
//        return duration.block().getSeconds();
//    }
//
//    /**
//     * 判断key是否存在
//     * @param key 键
//     * @return true 存在 false不存在
//     */
//    public static boolean hasKey(String key){
//        try {
//            Mono<Boolean> mono = redisTemplate.hasKey(key);
//            return mono.block().booleanValue();
//        } catch (Exception e) {
//            e.printStackTrace();
//            return false;
//        }
//    }
//
//    /**
//     * 删除缓存
//     * @param key 可以传一个值 或多个
//     */
//    @SuppressWarnings("unchecked")
//    public static void del(String ... key){
//        if(key!=null&&key.length>0){
//            if(key.length==1){
//                redisTemplate.delete(key[0]).block();
//            }else{
//                redisTemplate.delete(key).block();
//            }
//        }
//    }
//
//    //============================String=============================
//    /**
//     * 普通缓存获取
//     * @param key 键
//     * @return 值
//     */
//    public static Object get(String key){
//        return key==null?null:redisTemplate.opsForValue().get(key).block();
//    }
//
//    /**
//     * 普通缓存放入
//     * @param key 键
//     * @param value 值
//     * @return true成功 false失败
//     */
//    public static boolean set(String key,Object value) {
//        try {
//            redisTemplate.opsForValue().set(key, value).block();
//            return true;
//        } catch (Exception e) {
//            e.printStackTrace();
//            return false;
//        }
//    }
//
//    /**
//     * 普通缓存放入并设置时间
//     * @param key 键
//     * @param value 值
//     * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
//     * @return true成功 false 失败
//     */
//    public static boolean set(String key,Object value,long time){
//        try {
//            if(time>0){
//                if(null == value){return false;}
//                redisTemplate.opsForValue().set(key, value, Duration.ofSeconds(time)).block();
//            }else{
//                set(key, value);
//            }
//            return true;
//        } catch (Exception e) {
//            e.printStackTrace();
//            return false;
//        }
//    }
//
//    /**
//     * 递增
//     * @param key 键
//     * @param delta 要增加几(大于0)
//     * @return
//     */
//    public static long incr(String key, long delta){
//        if(delta<0){
//            throw new RuntimeException("递增因子必须大于0");
//        }
//        Mono<Long> mono = redisTemplate.opsForValue().increment(key, delta);
//        return mono.block().longValue();
//    }
//
//    /**
//     * 递减
//     * @param key 键
//     * @param delta 要减少几(小于0)
//     * @return
//     */
//    public static long decr(String key, long delta){
//        if(delta<0){
//            throw new RuntimeException("递减因子必须大于0");
//        }
//        Mono<Long> mono =  redisTemplate.opsForValue().increment(key, -delta);
//        return mono.block().longValue();
//    }
//
//    //================================Map=================================
//    /**
//     * HashGet
//     * @param key 键 不能为null
//     * @param item 项 不能为null
//     * @return 值
//     */
//    public static Object hget(String key,String item){
//        Mono mono = redisTemplate.opsForHash().get(key, item);
//        return mono.block();
//    }
//
//    /**
//     * 获取hashKey对应的所有键值
//     * @param key 键
//     * @return 对应的多个键值
//     */
//    public static Map<Object,Object> hmget(String key){
//        Flux<Map.Entry<Object, Object>> flux = redisTemplate.opsForHash().entries(key);
//        return (Map<Object, Object>) flux.buffer();
//    }
//
//    /**
//     * HashSet
//     * @param key 键
//     * @param map 对应多个键值
//     * @return true 成功 false 失败
//     */
//    public static boolean hmset(String key, Map<String,Object> map){
//        try {
//            redisTemplate.opsForHash().putAll(key, map).block();
//            return true;
//        } catch (Exception e) {
//            e.printStackTrace();
//            return false;
//        }
//    }
//
//    /**
//     * HashSet 并设置时间
//     * @param key 键
//     * @param map 对应多个键值
//     * @param time 时间(秒)
//     * @return true成功 false失败
//     */
//    public static boolean hmset(String key, Map<String,Object> map, long time){
//        try {
//            redisTemplate.opsForHash().putAll(key, map).block();
//            if(time>0){
//                expire(key, time);
//            }
//            return true;
//        } catch (Exception e) {
//            e.printStackTrace();
//            return false;
//        }
//    }
//
//    /**
//     * 向一张hash表中放入数据,如果不存在将创建
//     * @param key 键
//     * @param item 项
//     * @param value 值
//     * @return true 成功 false失败
//     */
//    public static boolean hset(String key,String item,Object value) {
//        try {
//            redisTemplate.opsForHash().put(key, item, value).block();
//            return true;
//        } catch (Exception e) {
//            e.printStackTrace();
//            return false;
//        }
//    }
//
//    /**
//     * 向一张hash表中放入数据,如果不存在将创建
//     * @param key 键
//     * @param item 项
//     * @param value 值
//     * @param time 时间(秒)  注意:如果已存在的hash表有时间,这里将会替换原有的时间
//     * @return true 成功 false失败
//     */
//    public static boolean hset(String key,String item,Object value,long time) {
//        try {
//            redisTemplate.opsForHash().put(key, item, value).block();
//            if(time>0){
//                expire(key, time);
//            }
//            return true;
//        } catch (Exception e) {
//            e.printStackTrace();
//            return false;
//        }
//    }
//
//    /**
//     * 删除hash表中的值
//     * @param key 键 不能为null
//     * @param item 项 可以使多个 不能为null
//     */
//    public static void hdel(String key, Object... item){
//        redisTemplate.opsForHash().remove(key,item).block();
//    }
//
//    /**
//     * 判断hash表中是否有该项的值
//     * @param key 键 不能为null
//     * @param item 项 不能为null
//     * @return true 存在 false不存在
//     */
//    public static boolean hHasKey(String key, String item){
//        Mono<Boolean> mono = redisTemplate.opsForHash().hasKey(key, item);
//        return mono.block();
//    }
//
//    /**
//     * hash递增 如果不存在,就会创建一个 并把新增后的值返回
//     * @param key 键
//     * @param item 项
//     * @param by 要增加几(大于0)
//     * @return
//     */
//    public static double hincr(String key, String item,double by){
//        Mono<Double> mono =  redisTemplate.opsForHash().increment(key, item, by);
//        return mono.block();
//    }
//
//    /**
//     * hash递减
//     * @param key 键
//     * @param item 项
//     * @param by 要减少记(小于0)
//     * @return
//     */
//    public static double hdecr(String key, String item,double by){
//        Mono<Double> mono =  redisTemplate.opsForHash().increment(key, item,-by);
//        return mono.block();
//    }
//
//    //============================set=============================
//    /**
//     * 根据key获取Set中的所有值
//     * @param key 键
//     * @return
//     */
//    public static List<Object> sGet(String key){
//        try {
//            Flux setFlux = redisTemplate.opsForSet().members(key);
//            return (List<Object>) setFlux.buffer().collect(Collectors.toList());
//        } catch (Exception e) {
//            e.printStackTrace();
//            return null;
//        }
//    }
//
//    /**
//     * 根据value从一个set中查询,是否存在
//     * @param key 键
//     * @param value 值
//     * @return true 存在 false不存在
//     */
//    public static boolean sHasKey(String key,Object value){
//        try {
//            Mono<Boolean> mono = redisTemplate.opsForSet().isMember(key, value);
//            return mono.block();
//        } catch (Exception e) {
//            e.printStackTrace();
//            return false;
//        }
//    }
//
//    /**
//     * 将数据放入set缓存
//     * @param key 键
//     * @param values 值 可以是多个
//     * @return 成功个数
//     */
//    public static long sSet(String key, String...values) {
//        try {
//            Mono<Long> mono = redisTemplate.opsForSet().add(key,  values);
//            return mono.block();
//        } catch (Exception e) {
//            e.printStackTrace();
//            return 0;
//        }
//    }
//
//    /**
//     * 将set数据放入缓存
//     * @param key 键
//     * @param time 时间(秒)
//     * @param values 值 可以是多个
//     * @return 成功个数
//     */
//    public static long sSetAndTime(String key,long time,String...values) {
//        try {
//            Mono<Long> mono = redisTemplate.opsForSet().add(key, values);
//            if(time>0) {
//                expire(key, time);
//            }
//            return mono.block();
//        } catch (Exception e) {
//            e.printStackTrace();
//            return 0;
//        }
//    }
//
//    /**
//     * 获取set缓存的长度
//     * @param key 键
//     * @return
//     */
//    public static long sGetSetSize(String key){
//        try {
//            Mono<Long> mono =  redisTemplate.opsForSet().size(key);
//            return mono.block();
//        } catch (Exception e) {
//            e.printStackTrace();
//            return 0;
//        }
//    }
//
//    /**
//     * 移除值为value的
//     * @param key 键
//     * @param values 值 可以是多个
//     * @return 移除的个数
//     */
//    public static long setRemove(String key, Object ...values) {
//        try {
//            Mono<Long> mono = redisTemplate.opsForSet().remove(key, values);
//            return mono.block();
//        } catch (Exception e) {
//            e.printStackTrace();
//            return 0;
//        }
//    }
//    //===============================list=================================
//
//    /**
//     * 获取list缓存的内容
//     * @param key 键
//     * @param start 开始
//     * @param end 结束  0 到 -1代表所有值
//     * @return
//     */
//    public static List<Object> lGet(String key, long start, long end){
//        try {
//            Flux flux = redisTemplate.opsForList().range(key, start, end);
//            return (List<Object>) flux.collect(Collectors.toList());
//        } catch (Exception e) {
//            e.printStackTrace();
//            return null;
//        }
//    }
//
//    /**
//     * 获取list缓存的长度
//     * @param key 键
//     * @return
//     */
//    public static long lGetListSize(String key){
//        try {
//            Mono<Long> mono = redisTemplate.opsForList().size(key);
//            return mono.block();
//        } catch (Exception e) {
//            e.printStackTrace();
//            return 0;
//        }
//    }
//
//    /**
//     * 通过索引 获取list中的值
//     * @param key 键
//     * @param index 索引  index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
//     * @return
//     */
//    public static Object lGetIndex(String key,long index){
//        try {
//            Mono<String> mono =  redisTemplate.opsForList().index(key, index);
//            return mono.block();
//        } catch (Exception e) {
//            e.printStackTrace();
//            return null;
//        }
//    }
//
//    /**
//     * 将list放入缓存
//     * @param key 键
//     * @param value 值
//     * @return
//     */
//    public static boolean lSet(String key, String value) {
//        try {
//            redisTemplate.opsForList().rightPush(key, value).block();
//            return true;
//        } catch (Exception e) {
//            e.printStackTrace();
//            return false;
//        }
//    }
//
//    /**
//     * 将list放入缓存
//     * @param key 键
//     * @param value 值
//     * @param time 时间(秒)
//     * @return
//     */
//    public static boolean lSet(String key, String value, long time) {
//        try {
//            redisTemplate.opsForList().rightPush(key, value).block();
//            if (time > 0) {
//                expire(key, time);
//            }
//            return true;
//        } catch (Exception e) {
//            e.printStackTrace();
//            return false;
//        }
//    }
//
//    /**
//     * 将list放入缓存
//     * @param key 键
//     * @param value 值
//     * @return
//     */
//    public static boolean lSet(String key, List<String> value) {
//        try {
//            redisTemplate.opsForList().rightPushAll(key, value).block();
//            return true;
//        } catch (Exception e) {
//            e.printStackTrace();
//            return false;
//        }
//    }
//
//    /**
//     * 将list放入缓存
//     * @param key 键
//     * @param value 值
//     * @param time 时间(秒)
//     * @return
//     */
//    public static boolean lSet(String key, List<String> value, long time) {
//        try {
//            redisTemplate.opsForList().rightPushAll(key, value).block();
//            if (time > 0) {
//                expire(key, time);
//            }
//            return true;
//        } catch (Exception e) {
//            e.printStackTrace();
//            return false;
//        }
//    }
//
//    /**
//     * 根据索引修改list中的某条数据
//     * @param key 键
//     * @param index 索引
//     * @param value 值
//     * @return
//     */
//    public static boolean lUpdateIndex(String key, long index,String value) {
//        try {
//            redisTemplate.opsForList().set(key, index, value).block();
//            return true;
//        } catch (Exception e) {
//            e.printStackTrace();
//            return false;
//        }
//    }
//
//    /**
//     * 移除N个值为value
//     * @param key 键
//     * @param count 移除多少个
//     * @param value 值
//     * @return 移除的个数
//     */
//    public static long lRemove(String key,long count,Object value) {
//        try {
//            Mono<Long> mono = redisTemplate.opsForList().remove(key, count, value);
//            return mono.block();
//        } catch (Exception e) {
//            e.printStackTrace();
//            return 0;
//        }
//    }
//
//    /**
//     * 模糊查询获取key值
//     * @param pattern
//     * @return
//     */
//    public static List keys(String pattern){
//        Flux flux = redisTemplate.keys(pattern);
//        return (List) flux.collect(Collectors.toList());
//    }
//
//    /**
//     * 使用Redis的消息队列
//     * @param channel
//     * @param message 消息内容
//     */
//    public static void convertAndSend(String channel, String message){
//        redisTemplate.convertAndSend(channel,message).block();
//    }
//
//
//    //=========BoundListOperations 用法 start============
//
//    /**
//     *将数据添加到Redis的list中（从右边添加）
//     * @param listKey
//     * @param expireEnum 有效期的枚举类
//     * @param values 待添加的数据
//     */
////    public static void addToListRight(String listKey, RedisStatus.ExpireEnum expireEnum, Object... values) {
////        //绑定操作
////        BoundListOperations<String, Object> boundValueOperations = redisTemplate.boundListOps(listKey);
////        //插入数据
////        boundValueOperations.rightPushAll(values);
////        //设置过期时间
////        boundValueOperations.expire(expireEnum.getTime(),expireEnum.getTimeUnit());
////    }
//    /**
//     * 根据起始结束序号遍历Redis中的list
//     * @param listKey
//     * @param start  起始序号
//     * @param end  结束序号
//     * @return
//     */
////    public static List<Object> rangeList(String listKey, long start, long end) {
////        //绑定操作
////        BoundListOperations<String, Object> boundValueOperations = redisTemplate.boundListOps(listKey);
////        //查询数据
////        return boundValueOperations.range(start, end);
////    }
//    /**
//     * 弹出右边的值 --- 并且移除这个值
//     * @param listKey
//     */
////    public static Object rifhtPop(String listKey){
////        //绑定操作
////        BoundListOperations<String, Object> boundValueOperations = redisTemplate.boundListOps(listKey);
////        return boundValueOperations.rightPop();
////    }
//
//    //=========BoundListOperations 用法 End============
//
//
//}
